/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package pfc;

import com.hp.hpl.jena.ontology.OntModel;
import edu.stanford.smi.protege.exception.OntologyLoadException;
import edu.stanford.smi.protege.model.Project;
import edu.stanford.smi.protegex.owl.ProtegeOWL;
import edu.stanford.smi.protegex.owl.jena.JenaKnowledgeBaseFactory;
import edu.stanford.smi.protegex.owl.jena.JenaOWLModel;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.Set;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.JFileChooser;
import javax.swing.filechooser.FileNameExtensionFilter;
import java.io.FileInputStream;
import java.util.Vector;

/**
 *
 * @author Administrador
 */
public class gestorProyecto {

    private Project originalVacio;
    private Util util = new Util();

    public gestorProyecto() {
    }

    public String abrirProyecto() {
        JFileChooser fileChooser = new JFileChooser();
        fileChooser.addChoosableFileFilter(new FileNameExtensionFilter("Proyecto Protege", "pprj"));
        int value = fileChooser.showOpenDialog(null);

        if (value == JFileChooser.APPROVE_OPTION) {
            File archivoAbierto = fileChooser.getSelectedFile();
            if (archivoAbierto.getName().contains(".pprj")) {
                return archivoAbierto.getPath();
            } else {
                javax.swing.JOptionPane.showMessageDialog(null, "No es un archivo válido");
                return null;
            }
        }
        return null;
    }

    @SuppressWarnings("static-access")
    public Project crearNuevoProyecto() {
        FileInputStream req = null;
        FileInputStream lel = null;

        try {

            originalVacio = cargarProyecto("src/ontologiaBase/OntoSRS_OntoLEL_OntoReq_vacia.pprj");

            JenaOWLModel owlModelReq = null;
            JenaOWLModel owlModelLel = null;

            String ontoReq = "src/ontologiaBase/OntoReq.owl";
            String ontoLel = "src/ontologiaBase/RE.LeL_ingles.owl";

            req = new FileInputStream(util.obtenerCamino(ontoReq));
            lel = new FileInputStream(util.obtenerCamino(ontoLel));


            owlModelReq = ProtegeOWL.createJenaOWLModelFromInputStream(req);
            owlModelLel = ProtegeOWL.createJenaOWLModelFromInputStream(lel);


            OntModel contenedor, contenido1, contenido2;

            contenedor = ((JenaOWLModel) originalVacio.getKnowledgeBase()).getOntModel();
            contenido1 = owlModelReq.getOntModel();
            contenido2 = owlModelLel.getOntModel();


            contenedor.getDocumentManager().addModel("http://www.owl-ontologies.com/OntoReq.owl", contenido1);
            contenedor.getDocumentManager().addModel("http://www.owl-ontologies.com/SE.RE.Elic.LeL.owl", contenido2);

            return originalVacio;

        } catch (OntologyLoadException ex) {
            Logger.getLogger(gestorProyecto.class.getName()).log(Level.SEVERE, null, ex);
        } catch (FileNotFoundException ex) {
            Logger.getLogger(gestorProyecto.class.getName()).log(Level.SEVERE, null, ex);
        } finally {
            try {
                req.close();
            } catch (IOException ex) {
                Logger.getLogger(gestorProyecto.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
        return null;
    }

    public Project cargarProyecto(String projectFileName) {
        ArrayList<Object> errors = new ArrayList<Object>();
        File file = new File(projectFileName);

        Project cargado = Project.loadProjectFromFile(file.getPath(), errors);

        if (esValido(cargado)) {
            return cargado;
        } else {
            javax.swing.JOptionPane.showMessageDialog(null, "No es un proyecto válido");
            return null;
        }
    }

    public void guardarProyecto(Project proyecto) {
        ArrayList<Object> errors = new ArrayList<Object>();

        if (proyecto.getName().equals("OntoSRS_OntoLEL_OntoReq_vacia")) {
            infoProyecto(proyecto);
            Boolean valor = datosNuevoProyecto(proyecto);
            if (valor == true) {
                proyecto.save(errors);
                handleErrors(errors);
            } else {
                return;
            }
        } else {
            fechaActualizacion(proyecto);
            proyecto.save(errors);
            handleErrors(errors);
        }
        return;
    }

    public void guardarComoProyecto(Project proyecto) {
        ArrayList<Object> errors = new ArrayList<Object>();
        infoProyecto(proyecto);
        Boolean valor = datosNuevoProyecto(proyecto);
        if (valor == true) {
            proyecto.save(errors);
            handleErrors(errors);
        } else {
            return;
        }
    }

    @SuppressWarnings("static-access")
    public Boolean datosNuevoProyecto(Project proyecto) {
        String caminoFilePPRJ;
        JFileChooser fileChooser = new JFileChooser();
        fileChooser.addChoosableFileFilter(new FileNameExtensionFilter("Proyecto Protege", "pprj"));
        int value = fileChooser.showSaveDialog(null);

        if (value == JFileChooser.APPROVE_OPTION) {
            File archivo = fileChooser.getSelectedFile();
            String path = util.obtenerCamino(archivo.getAbsolutePath());
            String nombre = archivo.getName().replaceAll(" ", "_");
            String caminoReal = path.substring(0, path.indexOf(archivo.getName()));
            caminoFilePPRJ = new String(caminoReal + nombre + ".pprj");
            proyecto.setProjectFilePath(caminoFilePPRJ);
            JenaKnowledgeBaseFactory.setOWLFileName(proyecto.getSources(), "file:///" + caminoReal.replaceAll(" ", "%20") + nombre + ".owl");
            cargarNombre(proyecto, nombre);
            return true;

        } else if (value == JFileChooser.CANCEL_OPTION) {
            return false;
        }
        return false;

    }

    /** Comprueba que el proyecto abierto tenga las ontologías correctas
     */
    private boolean esValido(Project cargado) {
        JenaOWLModel kb = (JenaOWLModel) cargado.getKnowledgeBase();
        Set<String> v = kb.getAllImports();
        String[] imports = new String[2];
        String[] importsAtener = {"http://www.owl-ontologies.com/OntoReq.owl", "http://www.owl-ontologies.com/SE.RE.Elic.LeL.owl"};
        boolean todos = true;
        int i = 0;

        if (v.size() != 0) { //si no tengo imports no entro

            for (Iterator<String> ite = v.iterator(); ite.hasNext();) {
                imports[i] = ite.next();
                i++;
            }

            for (int j = 0; j < 2; j++) {
                if (!imports[j].contains(importsAtener[j])) {
                    todos = false;
                    break;
                }
            }
            return todos;
        }

        return false;
    }

    private static void handleErrors(ArrayList<Object> errors) {
        Iterator<Object> i = errors.iterator();
        while (i.hasNext()) {
            System.out.println("Error: " + i.next());
        }
        if (!errors.isEmpty()) {
            System.exit(-1);
        }
    }

    public void imprimirPDF(cargaERS ers) {
        JFileChooser fileChooser = new JFileChooser();
        fileChooser.addChoosableFileFilter(new FileNameExtensionFilter("Portable Document Format", "pdf"));
        int value = fileChooser.showSaveDialog(null);

        if (value == JFileChooser.APPROVE_OPTION) {
            File archivo = fileChooser.getSelectedFile();

            PDF pdf = new PDF();
            Vector datos = ers.obtenerDatos();
            pdf.guardarPDF(archivo, datos);
        }
    }

    private void cargarFechas(Project pro) {
        GestorInformacion gi = new GestorInformacion(pro);
        gi.setFechaCreacion();
        gi.setFechaUltimaActualizacion();
    }

    private void cargarNombre(Project proyecto, String nombre) {
        GestorInformacion gi = new GestorInformacion(proyecto);
        gi.setNombreProyecto(nombre);
    }

    public void infoProyecto(Project proyecto) {
        PantallaInformacion infProyecto = new PantallaInformacion(null, true, proyecto);
        infProyecto.setLocationRelativeTo(null);
        infProyecto.setVisible(true);
        cargarFechas(proyecto);
    }

    private void fechaActualizacion(Project proyecto) {
        GestorInformacion gi = new GestorInformacion(proyecto);
        gi.setFechaUltimaActualizacion();
    }

    public String[] getInformacion(Project prj) {
        GestorInformacion gi = new GestorInformacion(prj);
        String[] datos = new String[5];
        if (gi.getNombreProyecto() == null) {
            datos[0] = new String("");
        } else {
            datos[0] = gi.getNombreProyecto();
        }
        if (gi.getID() == null) {
            datos[1] = new String("");
        } else {
            datos[1] = gi.getID();
        }
        if (gi.getLider() == null) {
            datos[2] = new String("");
        } else {
            datos[2] = gi.getLider();
        }
        if (gi.getFechaCreacion() == null) {
            datos[3] = new String("");
        } else {
            datos[3] = gi.getFechaCreacion();
        }
        if (gi.getFechaUltimaActualizacion() == null) {
            datos[4] = new String("");
        } else {
            datos[4] = gi.getFechaUltimaActualizacion();
        }

        return datos;
    }
}
